#include "icsearch.hpp"
#include "user.hxx"
// #include "message.hxx"

namespace mag {

    // Elasticsearch客户端工厂类，负责创建ES客户端实例
    class ESClientFactory {
    public:
        // 创建并返回一个 Elasticsearch 客户端实例
        static std::shared_ptr<elasticlient::Client> create(const std::vector<std::string> host_list) {
            try {
                // 使用提供的主机列表创建并返回ES客户端
                return std::make_shared<elasticlient::Client>(host_list);
            } catch (const std::exception &e) {
                // 记录错误并重新抛出异常
                LOG_ERROR("Failed to create Elasticsearch client: {}", e.what());
                throw;
            }
        }
    };

    // 用户索引管理类
    class ESUser {
    public:
        using ptr = std::shared_ptr<ESUser>;

        // 构造函数，接收ES客户端实例
        ESUser(const std::shared_ptr<elasticlient::Client> &client) : _es_client(client) {}

        // 创建用户信息索引
        bool createIndex() {
            bool ret = ESIndex(_es_client, "user")
                .append("user_id", "keyword", "standard", true)
                .append("nickname")
                .append("phone", "keyword", "standard", true)
                .append("description", "text", "standard", false)
                .append("avatar_id", "keyword", "standard", false)
                .create();
            
            if (!ret) {
                LOG_INFO("用户信息索引创建失败!");
                return false;
            }
            LOG_INFO("用户信息索引创建成功!");
            return true;
        }

        // 向ES插入或更新用户数据
        bool appendData(const std::string &uid,
            const std::string &phone,
            const std::string &nickname,
            const std::string &description,
            const std::string &avatar_id) {
            bool ret = ESInsert(_es_client, "user")
                .append("user_id", uid)
                .append("nickname", nickname)
                .append("phone", phone)
                .append("description", description)
                .append("avatar_id", avatar_id)
                .insert(uid);
            
            if (!ret) {
                LOG_ERROR("用户数据插入/更新失败!");
                return false;
            }
            LOG_INFO("用户数据新增/更新成功!");
            return true;
        }

        // 搜索用户
        std::vector<User> search(const std::string &key, const std::vector<std::string> &uid_list) {
            std::vector<User> res;

            // 搜索用户数据，条件包括匹配手机号、用户ID和昵称
            Json::Value json_user = ESSearch(_es_client, "user")
                .append_should_match("phone.keyword", key)
                .append_should_match("user_id.keyword", key)
                .append_should_match("nickname", key)
                .append_must_not_terms("user_id.keyword", uid_list)
                .search();

            // 检查返回结果是否为数组类型
            if (!json_user.isArray()) {
                LOG_ERROR("用户搜索结果为空，或者结果不是数组类型");
                return res;
            }

            // 遍历每个搜索结果并创建User对象
            int sz = json_user.size();
            LOG_DEBUG("检索结果条目数量：{}", sz);
            for (int i = 0; i < sz; i++) {
                User user;
                user.user_id(json_user[i]["_source"]["user_id"].asString());
                user.nickname(json_user[i]["_source"]["nickname"].asString());
                user.description(json_user[i]["_source"]["description"].asString());
                user.phone(json_user[i]["_source"]["phone"].asString());
                user.avatar_id(json_user[i]["_source"]["avatar_id"].asString());
                res.push_back(user);
            }

            return res;
        }

    private:
        std::shared_ptr<elasticlient::Client> _es_client;  // Elasticsearch 客户端
    };

    // 消息索引管理类
    // class ESMessage {
    // public:
    //     using ptr = std::shared_ptr<ESMessage>;

    //     // 构造函数，接收ES客户端实例
    //     ESMessage(const std::shared_ptr<elasticlient::Client> &es_client) : _es_client(es_client) {}

    //     // 创建消息信息索引
    //     bool createIndex() {
    //         bool ret = ESIndex(_es_client, "message")
    //             .append("user_id", "keyword", "standard", false)
    //             .append("message_id", "keyword", "standard", false)
    //             .append("create_time", "long", "standard", false)
    //             .append("chat_session_id", "keyword", "standard", true)
    //             .append("content")
    //             .create();

    //         if (!ret) {
    //             LOG_INFO("消息信息索引创建失败!");
    //             return false;
    //         }
    //         LOG_INFO("消息信息索引创建成功!");
    //         return true;
    //     }

    //     // 向消息索引插入或更新消息数据
    //     bool appendData(const std::string &user_id,
    //         const std::string &message_id,
    //         const long create_time,
    //         const std::string &chat_session_id,
    //         const std::string &content) {
    //         bool ret = ESInsert(_es_client, "message")
    //             .append("message_id", message_id)
    //             .append("create_time", create_time)
    //             .append("user_id", user_id)
    //             .append("chat_session_id", chat_session_id)
    //             .append("content", content)
    //             .insert(message_id);

    //         if (!ret) {
    //             LOG_ERROR("消息数据插入/更新失败!");
    //             return false;
    //         }
    //         LOG_INFO("消息数据新增/更新成功!");
    //         return true;
    //     }

    //     // 删除消息数据
    //     bool remove(const std::string &mid) {
    //         bool ret = ESRemove(_es_client, "message").remove(mid);
    //         if (!ret) {
    //             LOG_ERROR("消息数据删除失败!");
    //             return false;
    //         }
    //         LOG_INFO("消息数据删除成功!");
    //         return true;
    //     }

    //     // 搜索消息
    //     std::vector<bite_im::Message> search(const std::string &key, const std::string &ssid) {
    //         std::vector<bite_im::Message> res;

    //         // 搜索消息内容及会话ID
    //         Json::Value json_user = ESSearch(_es_client, "message")
    //             .append_must_term("chat_session_id.keyword", ssid)
    //             .append_must_match("content", key)
    //             .search();

    //         // 检查返回结果是否为数组类型
    //         if (!json_user.isArray()) {
    //             LOG_ERROR("消息搜索结果为空，或者结果不是数组类型");
    //             return res;
    //         }

    //         // 遍历每个搜索结果并创建Message对象
    //         int sz = json_user.size();
    //         LOG_DEBUG("检索结果条目数量：{}", sz);
    //         for (int i = 0; i < sz; i++) {
    //             bite_im::Message message;
    //             message.user_id(json_user[i]["_source"]["user_id"].asString());
    //             message.message_id(json_user[i]["_source"]["message_id"].asString());

    //             // 解析时间戳
    //             boost::posix_time::ptime ctime(boost::posix_time::from_time_t(
    //                 json_user[i]["_source"]["create_time"].asInt64()));
    //             message.create_time(ctime);
                
    //             // 设置其他字段
    //             message.session_id(json_user[i]["_source"]["chat_session_id"].asString());
    //             message.content(json_user[i]["_source"]["content"].asString());

    //             res.push_back(message);
    //         }

    //         return res;
    //     }

    // private:
    //     std::shared_ptr<elasticlient::Client> _es_client;  // Elasticsearch 客户端
    // };

}  // namespace mag
